#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
自动测试脚本
无需用户交互，自动运行所有数据处理步骤，并确保每个步骤的输出数据
都以可视化文件和Excel文件的形式呈现
"""

import os
import sys
import pandas as pd
import matplotlib.pyplot as plt
from datetime import datetime
import logging
import time
from pathlib import Path

# 添加项目根目录到Python路径
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))

# 导入自定义模块
try:
    from data_processing_test import DataProcessingTester
    logging.basicConfig(level=logging.INFO,
                        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    logger = logging.getLogger('auto_test')
    logger.info("已成功导入必要的模块")
except Exception as e:
    print(f"导入模块失败: {str(e)}")
    # 使用内置logging作为备选
    logging.basicConfig(level=logging.INFO,
                        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    logger = logging.getLogger('auto_test')
    logger.error(f"导入模块失败: {str(e)}")
    sys.exit(1)

class AutoTestRunner:
    """
    自动测试运行器类
    负责自动化执行所有测试步骤并生成报告
    """
    
    def __init__(self):
        """
        初始化自动测试运行器
        """
        self.tester = None
        self.start_time = None
        self.end_time = None
        
        # 初始化数据处理测试器
        try:
            self.tester = DataProcessingTester()
            logger.info("初始化DataProcessingTester成功")
        except Exception as e:
            logger.error(f"初始化DataProcessingTester失败: {str(e)}")
            raise
    
    def run_all_phases(self):
        """
        运行所有数据处理阶段
        """
        print("\n🎉 开始自动测试流程 🎉")
        print("=" * 60)
        print(f"开始时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        
        self.start_time = datetime.now()
        phase_results = {}
        success = True
        
        # 1. 前处理阶段
        print("\n" + "-" * 60)
        print("🔍 执行前处理阶段...")
        phase_start = time.time()
        if self.tester.pre_processing_phase():
            phase_time = time.time() - phase_start
            phase_results['前处理阶段'] = {'状态': '成功', '耗时(秒)': round(phase_time, 2)}
            print(f"✅ 前处理阶段完成，耗时: {phase_time:.2f}秒")
        else:
            success = False
            phase_results['前处理阶段'] = {'状态': '失败'}
            print("❌ 前处理阶段失败")
        
        # 2. 数据预处理阶段
        if success:
            print("\n" + "-" * 60)
            print("🔍 执行数据预处理阶段...")
            phase_start = time.time()
            if self.tester.data_preprocessing_phase():
                phase_time = time.time() - phase_start
                phase_results['数据预处理阶段'] = {'状态': '成功', '耗时(秒)': round(phase_time, 2)}
                print(f"✅ 数据预处理阶段完成，耗时: {phase_time:.2f}秒")
            else:
                success = False
                phase_results['数据预处理阶段'] = {'状态': '失败'}
                print("❌ 数据预处理阶段失败")
        
        # 3. 任务分类与数据匹配阶段
        if success:
            print("\n" + "-" * 60)
            print("🔍 执行任务分类与数据匹配阶段...")
            phase_start = time.time()
            if self.tester.task_classification_matching_phase():
                phase_time = time.time() - phase_start
                phase_results['任务分类与数据匹配阶段'] = {'状态': '成功', '耗时(秒)': round(phase_time, 2)}
                print(f"✅ 任务分类与数据匹配阶段完成，耗时: {phase_time:.2f}秒")
            else:
                success = False
                phase_results['任务分类与数据匹配阶段'] = {'状态': '失败'}
                print("❌ 任务分类与数据匹配阶段失败")
        
        # 4. 数据后处理阶段
        if success:
            print("\n" + "-" * 60)
            print("🔍 执行数据后处理阶段...")
            phase_start = time.time()
            if self.tester.data_postprocessing_phase():
                phase_time = time.time() - phase_start
                phase_results['数据后处理阶段'] = {'状态': '成功', '耗时(秒)': round(phase_time, 2)}
                print(f"✅ 数据后处理阶段完成，耗时: {phase_time:.2f}秒")
            else:
                success = False
                phase_results['数据后处理阶段'] = {'状态': '失败'}
                print("❌ 数据后处理阶段失败")
        
        self.end_time = datetime.now()
        total_duration = (self.end_time - self.start_time).total_seconds()
        
        print("\n" + "=" * 60)
        print(f"结束时间: {self.end_time.strftime('%Y-%m-%d %H:%M:%S')}")
        print(f"总耗时: {total_duration:.2f} 秒")
        
        # 生成测试报告
        self._generate_test_report(phase_results, success, total_duration)
        
        if success:
            print("\n🎉 自动测试流程已成功完成！")
            self._print_output_locations()
        else:
            print("\n❌ 自动测试流程未能全部成功完成！")
        
        return success
    
    def _generate_test_report(self, phase_results, success, total_duration):
        """
        生成测试报告
        """
        try:
            # 创建报告数据
            report_data = []
            for phase, result in phase_results.items():
                row = {'阶段': phase}
                row.update(result)
                report_data.append(row)
            
            report_df = pd.DataFrame(report_data)
            
            # 确保报告目录存在
            report_dir = os.path.join(os.path.dirname(__file__), 'test_results', 'reports')
            os.makedirs(report_dir, exist_ok=True)
            
            # 生成带时间戳的文件名
            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
            report_filename = f"测试报告_{timestamp}.xlsx"
            report_path = os.path.join(report_dir, report_filename)
            
            # 保存为Excel报告
            with pd.ExcelWriter(report_path, engine='openpyxl') as writer:
                # 写入测试结果
                report_df.to_excel(writer, sheet_name='测试结果', index=False)
                
                # 添加统计信息
                stats_sheet = writer.book.create_sheet('统计信息')
                stats_sheet['A1'] = '测试统计信息'
                stats_sheet['A2'] = '开始时间'
                stats_sheet['B2'] = self.start_time.strftime('%Y-%m-%d %H:%M:%S')
                stats_sheet['A3'] = '结束时间'
                stats_sheet['B3'] = self.end_time.strftime('%Y-%m-%d %H:%M:%S')
                stats_sheet['A4'] = '总耗时(秒)'
                stats_sheet['B4'] = f"{total_duration:.2f}"
                stats_sheet['A5'] = '测试状态'
                stats_sheet['B5'] = '成功' if success else '失败'
                
                # 设置列宽
                stats_sheet.column_dimensions['A'].width = 15
                stats_sheet.column_dimensions['B'].width = 30
            
            print(f"\n📊 测试报告已生成: {report_path}")
            return report_path
            
        except Exception as e:
            logger.error(f"生成测试报告失败: {str(e)}")
            print(f"❌ 生成测试报告失败: {str(e)}")
            return None
    
    def _print_output_locations(self):
        """
        打印输出文件位置信息
        """
        try:
            # 获取输出目录信息
            test_results_dir = os.path.join(os.path.dirname(__file__), 'test_results', 'processed_data')
            visualizations_dir = os.path.join(os.path.dirname(__file__), 'test_results', 'visualizations')
            reports_dir = os.path.join(os.path.dirname(__file__), 'test_results', 'reports')
            
            # 统计生成的文件数量
            csv_files = [f for f in os.listdir(test_results_dir) if f.endswith('.csv')]
            excel_files = [f for f in os.listdir(test_results_dir) if f.endswith('.xlsx')]
            viz_files = []
            for root, _, files in os.walk(visualizations_dir):
                viz_files.extend([os.path.join(root, f) for f in files if f.endswith(('.png', '.jpg', '.jpeg'))])
            
            print("\n📋 输出文件统计:")
            print("-" * 60)
            print(f"CSV数据文件: {len(csv_files)} 个")
            print(f"Excel数据文件: {len(excel_files)} 个")
            print(f"可视化图像文件: {len(viz_files)} 个")
            print("\n📂 输出文件位置:")
            print("-" * 60)
            print(f"数据文件目录: {test_results_dir}")
            print(f"可视化文件目录: {visualizations_dir}")
            print(f"报告文件目录: {reports_dir}")
            
            # 显示每个阶段生成的可视化文件
            print("\n🔍 各阶段可视化文件:")
            print("-" * 60)
            for phase_dir in ['1_前处理阶段', '2_预处理阶段', '3_分类匹配阶段', '4_后处理阶段']:
                phase_path = os.path.join(visualizations_dir, phase_dir)
                if os.path.exists(phase_path):
                    files = os.listdir(phase_path)
                    if files:
                        print(f"\n{phase_dir}:")
                        for file in sorted(files):
                            print(f"  - {file}")
        
        except Exception as e:
            logger.error(f"打印输出位置信息失败: {str(e)}")
            print(f"❌ 获取输出位置信息时出错: {str(e)}")

def main():
    """
    主函数
    """
    print("🤖 自动数据处理测试工具 v1.0")
    print("==============================\n")
    print("本工具将自动执行所有数据处理步骤，并为每个步骤生成:")
    print("  • CSV格式的数据文件")
    print("  • Excel格式的数据文件")
    print("  • 可视化图表文件")
    print("  • 测试报告文件\n")
    
    try:
        # 创建自动测试运行器实例
        runner = AutoTestRunner()
        
        # 运行所有阶段
        success = runner.run_all_phases()
        
        if success:
            print("\n✅ 自动测试完成！")
            return 0
        else:
            print("\n❌ 自动测试失败！")
            return 1
            
    except KeyboardInterrupt:
        print("\n\n🛑 测试被用户中断")
        return 1
    except Exception as e:
        print(f"\n❌ 程序执行异常: {str(e)}")
        import traceback
        traceback.print_exc()
        return 1

if __name__ == "__main__":
    sys.exit(main())